SherbyNet - /page/wikibook/entry.mu

Micron Document

<!DOCTYPE html>

<title>Function pointer</title>

</head>

Function pointer

</h1>

</header>

A function pointer, also called a subroutine pointer or procedure pointer, is a <a href="Pointer_(computer_programming)" title="Pointer (computer programming)">pointer</a> referencing executable code, rather than data. <a href="Dereference_operator" class="mw-redirect" title="Dereference operator">Dereferencing</a> the function pointer yields the referenced <a href="Subroutine" class="mw-redirect" title="Subroutine">function</a>, which can be invoked and passed arguments just as in a normal function call. Such an invocation is also known as an "indirect" call, because the function is being invoked indirectly through a variable instead of directly through a fixed identifier or address.

Function pointers allow different code to be executed at runtime. They can also be passed to a function to enable <a href="Callback_(computer_programming)" title="Callback (computer programming)">callbacks</a>.

Function pointers are supported by <a href="Third-generation_programming_language" title="Third-generation programming language">third-generation</a> <a href="Programming_language" title="Programming language">programming languages</a> (such as <a href="PL/I" title="PL/I">PL/I</a>, <a href="COBOL" title="COBOL">COBOL</a>, <a href="Fortran" title="Fortran">Fortran</a>,<a href="#cite_note-1">[1]</a> <a href="DBASE" class="mw-redirect" title="DBASE">dBASE</a> dBL, and <a href="C_(programming_language)" title="C (programming language)">C</a>) and <a href="Object-oriented_programming" title="Object-oriented programming">object-oriented programming</a> languages (such as <a href="C%2B%2B" title="C++">C++</a>, <a href="C_Sharp_(programming_language)" title="C Sharp (programming language)">C#</a>, and <a href="D_(programming_language)" title="D (programming language)">D</a>).<a href="#cite_note-2">[2]</a>

<div class="mw-heading mw-heading2"><h2 id="Simple_function_pointers">Simple function pointers</h2></div>

The simplest implementation of a function (or subroutine) pointer is as a <a href="Variable_(computer_science)" title="Variable (computer science)">variable</a> containing the <a href="Memory_address" title="Memory address">address</a> of the function within executable memory. Older <a href="Third-generation_programming_language" title="Third-generation programming language">third-generation languages</a> such as <a href="PL/I" title="PL/I">PL/I</a> and <a href="COBOL" title="COBOL">COBOL</a>, as well as more modern languages such as <a href="Pascal_(programming_language)" title="Pascal (programming language)">Pascal</a> and <a href="C_(programming_language)" title="C (programming language)">C</a> generally implement function pointers in this manner.<a href="#cite_note-3">[3]</a>

<div class="mw-heading mw-heading3"><h3 id="Example_in_C">Example in C</h3></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .hatnote{font-style:italic}.mw-parser-output div.hatnote{padding-left:1.6em;margin-bottom:0.5em}.mw-parser-output .hatnote i{font-style:normal}.mw-parser-output .hatnote+link+.hatnote{margin-top:-0.5em}@media print{body.ns-0 .mw-parser-output .hatnote{display:none!important}}

/* end https://en.wikipedia.org/ */

</style><div role="note" class="hatnote navigation-not-searchable">See also: <a href="#Alternate_C_and_C++_syntax">§ Alternate C and C++ syntax</a></div>

The following C program illustrates the use of two function pointers:

<ul><li>func1 takes one double-precision (double) parameter and returns another double, and is assigned to a function which converts centimeters to inches.</li>

<li>func2 takes a pointer to a constant character array as well as an integer and returns a pointer to a character, and is assigned to a <a href="C_string_handling" title="C string handling">C string handling</a> function which returns a pointer to the first occurrence of a given character in a character array.</li></ul>

<div class="mw-highlight mw-highlight-lang-c mw-content-ltr" dir="ltr"><pre>#include <stdio.h> /* for printf */

#include <string.h> /* for strchr */

double cm_to_inches(double cm) {

return cm / 2.54;

}

// "strchr" is part of the C string handling (i.e., no need for declaration)

// See https://en.wikipedia.org/wiki/C_string_handling#Functions

int main(void) {

double (*func1)(double) = cm_to_inches;

char * (*func2)(const char *, int) = strchr;

printf("%f %s", func1(15.0), func2("Wikipedia", 'p'));

/* prints "5.905512 pedia" */

return 0;

}

</pre></div>

The next program uses a function pointer to invoke one of two functions (<code>sin</code> or <code>cos</code>) indirectly from another function (<code>compute_sum</code>, computing an approximation of the function's <a href="Riemann_integration" class="mw-redirect" title="Riemann integration">Riemann integration</a>). The program operates by having function <code>main</code> call function <code>compute_sum</code> twice, passing it a pointer to the library function <code>sin</code> the first time, and a pointer to function <code>cos</code> the second time. Function <code>compute_sum</code> in turn invokes one of the two functions indirectly by dereferencing its function pointer argument <code>funcp</code> multiple times, adding together the values that the invoked function returns and returning the resulting sum. The two sums are written to the standard output by <code>main</code>.

<div class="mw-highlight mw-highlight-lang-c mw-content-ltr mw-highlight-lines" dir="ltr"><pre>#include <math.h>

#include <stdio.h>

// Function taking a function pointer as an argument

double compute_sum(double (*funcp)(double), double lo, double hi) {

double sum = 0.0;

// Add values returned by the pointed-to function '*funcp'

int i;

for (i = 0; i <= 100; i++) {

// Use the function pointer 'funcp' to invoke the function

double x = i / 100.0 * (hi - lo) + lo;

double y = funcp(x);

sum += y;

}

return sum / 101.0 * (hi - lo);

}

double square(double x) {

return x * x;

}

double sum;

// Use standard library function 'sin()' as the pointed-to function

sum = compute_sum(sin, 0.0, 1.0);

printf("sum(sin): %g\n", sum);

// Use standard library function 'cos()' as the pointed-to function

sum = compute_sum(cos, 0.0, 1.0);

printf("sum(cos): %g\n", sum);

// Use user-defined function 'square()' as the pointed-to function

sum = compute_sum(square, 0.0, 1.0);

printf("sum(square): %g\n", sum);

return 0;

}

</pre></div>

<div class="mw-heading mw-heading2"><h2 id="Functors">Functors</h2></div>

<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="Function_object" title="Function object">Function object</a></div>

Functors, or function objects, are similar to function pointers, and can be used in similar ways. A functor is an object of a class type that implements the <a href="Function-call_operator" class="mw-redirect" title="Function-call operator">function-call operator</a>, allowing the object to be used within expressions using the same syntax as a function call. Functors are more powerful than simple function pointers, being able to contain their own data values, and allowing the programmer to emulate <a href="Closure_(computer_programming)" title="Closure (computer programming)">closures</a>. They are also used as callback functions if it is necessary to use a member function as a callback function.<a href="#cite_note-4">[4]</a>

Many "pure" object-oriented languages do not <a href="Support_function" title="Support function">support function</a> pointers. Something similar can be implemented in these kinds of languages, though, using <a href="Reference_(computer_science)" title="Reference (computer science)">references</a> to <a href="Protocol_(object-oriented_programming)" class="mw-redirect" title="Protocol (object-oriented programming)">interfaces</a> that define a single <a href="Method_(computer_programming)" title="Method (computer programming)">method</a> (member function). <a href="List_of_CLI_languages" title="List of CLI languages">CLI languages</a> such as <a href="C_Sharp_(programming_language)" title="C Sharp (programming language)">C#</a> and <a href="Visual_Basic_.NET" class="mw-redirect" title="Visual Basic .NET">Visual Basic .NET</a> implement <a href="Type_safety" title="Type safety">type-safe</a> function pointers with <a href="Delegate_(CLI)" title="Delegate (CLI)">delegates</a>.

In other languages that support <a href="First-class_function" title="First-class function">first-class functions</a>, functions are regarded as data, and can be passed, returned, and created dynamically directly by other functions, eliminating the need for function pointers.

Extensively using function pointers to call functions may produce a slow-down for the code on modern processors, because a <a href="Branch_predictor" title="Branch predictor">branch predictor</a> may not be able to figure out where to branch to (it depends on the value of the function pointer at run time) although this effect can be overstated as it is often amply compensated for by significantly reduced non-indexed table lookups.

<div class="mw-heading mw-heading2"><h2 id="Method_pointers">Method pointers</h2></div>

C++ includes support for <a href="Object-oriented_programming" title="Object-oriented programming">object-oriented programming</a>, so classes can have <a href="Method_(computer_programming)" title="Method (computer programming)">methods</a> (usually referred to as member functions). Non-static member functions (instance methods) have an implicit parameter (the <a href="This_(computer_programming)" title="This (computer programming)">this</a> pointer) which is the pointer to the object it is operating on, so the type of the object must be included as part of the type of the function pointer. The method is then used on an object of that class by using one of the "pointer-to-member" operators: <code>.*</code> or <code>->*</code> (for an object or a pointer to object, respectively).

Although function pointers in C and C++ can be implemented as simple addresses, so that typically <code>sizeof(Fx)==sizeof(void *)</code>, member pointers in C++ are sometimes implemented as "<a href="Fat_pointer" class="mw-redirect" title="Fat pointer">fat pointers</a>", typically two or three times the size of a simple function pointer, in order to deal with <a href="Virtual_methods" class="mw-redirect" title="Virtual methods">virtual methods</a> and <a href="Virtual_inheritance" title="Virtual inheritance">virtual inheritance</a>.

In C++, in addition to the method used in C, it is also possible to use the <a href="C%2B%2B_Standard_Library" title="C++ Standard Library">C++ standard library</a> class template <style data-mw-deduplicate="TemplateStyles:r886049734">

/* start https://en.wikipedia.org/ */

.mw-parser-output .monospaced{font-family:monospace,monospace}

/* end https://en.wikipedia.org/ */

</style>std::function, of which the instances are function objects:

<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><pre>#include <iostream>

#include <functional>

using namespace std;

static double derivative(const function<double(double)> &f, double x0, double eps) {

double eps2 = eps / 2;

double lo = x0 - eps2;

double hi = x0 + eps2;

return (f(hi) - f(lo)) / eps;

}

static double f(double x) {

}

int main() {

cout << "d/dx(x ^ 2) [@ x = " << x << "] = " << derivative(f, x, 1e-5) << endl;

return 0;

}

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Pointers_to_member_functions_in_C++">Pointers to member functions in C++</h3></div>

<div role="note" class="hatnote navigation-not-searchable">See also: <a href="#Alternate_C_and_C++_syntax">§ Alternate C and C++ syntax</a></div>

This is how C++ uses function pointers when dealing with member functions of classes or structs. These are invoked using an object pointer or a this call. They are type safe in that you can only call members of that class (or derivatives) using a pointer of that type. This example also demonstrates the use of a typedef for the pointer to member function added for simplicity. Function pointers to static member functions are done in the traditional 'C' style because there is no object pointer for this call required.

<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><pre>#include <iostream>

using namespace std;

class Foo {

public:

int add(int i, int j) {

return i+j;

}

int mult(int i, int j) {

return i*j;

}

static int negate(int i) {

return -i;

}

};

int bar1(int i, int j, Foo* pFoo, int(Foo::*pfn)(int,int)) {

return (pFoo->*pfn)(i,j);

}

typedef int(Foo::*Foo_pfn)(int,int);

int bar2(int i, int j, Foo* pFoo, Foo_pfn pfn) {

}

typedef auto(*PFN)(int) -> int;

// C++ only, same as: typedef int(*PFN)(int);

int bar3(int i, PFN pfn) {

return pfn(i);

}

int main() {

Foo foo;

cout << "Foo::add(2,4) = " << bar1(2,4, &foo, &Foo::add) << endl;

cout << "Foo::mult(3,5) = " << bar2(3,5, &foo, &Foo::mult) << endl;

cout << "Foo::negate(6) = " << bar3(6, &Foo::negate) << endl;

return 0;

}

</pre></div>

<div class="mw-heading mw-heading2"><h2 id="Alternate_C_and_C++_syntax">Alternate C and C++ syntax</h2></div>

The C and <a href="C%2B%2B_syntax" title="C++ syntax">C++ syntax</a> given above is the canonical one used in all the textbooks - but it's difficult to read and explain. Even the above <code>typedef</code> examples use this syntax. However, every C and C++ compiler supports a more clear and concise mechanism to declare function pointers: use <code>typedef</code>, but don't store the pointer as part of the definition. Note that the only way this kind of <code>typedef</code> can actually be used is with a pointer - but that highlights the pointer-ness of it.

<div class="mw-highlight mw-highlight-lang-c mw-content-ltr" dir="ltr"><pre>// This declares 'F', a function that accepts a 'char' and returns an 'int'. Definition is elsewhere.

int F(char c);

// This defines 'Fn', a type of function that accepts a 'char' and returns an 'int'.

typedef int Fn(char c);

// This defines 'fn', a variable of type pointer-to-'Fn', and assigns the address of 'F' to it.

Fn *fn = &F; // Note '&' not required - but it highlights what is being done.

// This calls 'F' using 'fn', assigning the result to the variable 'a'

int a = fn('A');

// This defines 'Call', a function that accepts a pointer-to-'Fn', calls it, and returns the result

int Call(Fn *fn, char c) {

return fn(c);

} // Call(fn, c)

// This calls function 'Call', passing in 'F' and assigning the result to 'call'

int call = Call(&F, 'A'); // Again, '&' is not required

// LEGACY: Note that to maintain existing code bases, the above definition style can still be used first;

// then the original type can be defined in terms of it using the new style.

// This defines 'PFn', a type of pointer-to-type-Fn.

typedef Fn *PFn;

// 'PFn' can be used wherever 'Fn *' can

PFn pfn = F;

int CallP(PFn fn, char c);

</pre></div>

These examples use the above definitions. In particular, note that the above definition for <code>Fn</code> can be used in pointer-to-member-function definitions:

<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><pre>// This defines 'C', a class with similar static and member functions,

// and then creates an instance called 'c'

class C {

public:

static int Static(char c);

int Member(char c);

} c; // C

// This defines 'p', a pointer to 'C' and assigns the address of 'c' to it

C *p = &c;

// This assigns a pointer-to-'Static' to 'fn'.

// Since there is no 'this', 'Fn' is the correct type; and 'fn' can be used as above.

fn = &C::Static;

// This defines 'm', a pointer-to-member-of-'C' with type 'Fn',

// and assigns the address of 'C::Member' to it.

// You can read it right-to-left like all pointers:

// "'m' is a pointer to member of class 'C' of type 'Fn'"

Fn C::*m = &C::Member;

// This uses 'm' to call 'Member' in 'c', assigning the result to 'cA'

int cA = (c.*m)('A');

// This uses 'm' to call 'Member' in 'p', assigning the result to 'pA'

int pA = (p->*m)('A');

// This defines 'Ref', a function that accepts a reference-to-'C',

// a pointer-to-member-of-'C' of type 'Fn', and a 'char',

// calls the function and returns the result

int Ref(C &r, Fn C::*m, char c) {

return (r.*m)(c);

} // Ref(r, m, c)

// This defines 'Ptr', a function that accepts a pointer-to-'C',

// a pointer-to-member-of-'C' of type 'Fn', and a 'char',

// calls the function and returns the result

int Ptr(C *p, Fn C::*m, char c) {

return (p->*m)(c);

} // Ptr(p, m, c)

// LEGACY: Note that to maintain existing code bases, the above definition style can still be used first;

// then the original type can be defined in terms of it using the new style.

// This defines 'FnC', a type of pointer-to-member-of-class-'C' of type 'Fn'

typedef Fn C::*FnC;

// 'FnC' can be used wherever 'Fn C::*' can

FnC fnC = &C::Member;

int RefP(C &p, FnC m, char c);

</pre></div>

<a href="PL/I" title="PL/I">PL/I</a> procedures can be nested, that is, procedure A may contain procedure B, which in turn may contain C. In addition to data declared in B, B can also reference any data declared in A, as long as it doesn’t override the definition. Likewise C can reference data in both A and B. Therefore, PL/I ENTRY variables need to contain context,<a href="#cite_note-5">[5]</a> to provide procedure C with the addresses of the values of data in B and A at the time C was called.

<ul><li><a href="Delegation_(computing)" title="Delegation (computing)">Delegation (computing)</a></li>

<li><a href="Function_object" title="Function object">Function object</a></li>

<li><a href="Higher-order_function" title="Higher-order function">Higher-order function</a></li>

<li><a href="Procedural_parameter" title="Procedural parameter">Procedural parameter</a></li>

<li><a href="Closure_(computer_programming)" title="Closure (computer programming)">Closure</a></li>

<li><a href="Anonymous_function" title="Anonymous function">Anonymous functions</a></li></ul>

<div class="mw-heading mw-heading2"><h2 id="References">References</h2></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .reflist{margin-bottom:0.5em;list-style-type:decimal}@media screen{.mw-parser-output .reflist{font-size:90%}}.mw-parser-output .reflist .references{font-size:100%;margin-bottom:0;list-style-type:inherit}.mw-parser-output .reflist-columns-2{column-width:30em}.mw-parser-output .reflist-columns-3{column-width:25em}.mw-parser-output .reflist-columns{margin-top:0.3em}.mw-parser-output .reflist-columns ol{margin-top:0}.mw-parser-output .reflist-columns li{page-break-inside:avoid;break-inside:avoid-column}.mw-parser-output .reflist-upper-alpha{list-style-type:upper-alpha}.mw-parser-output .reflist-upper-roman{list-style-type:upper-roman}.mw-parser-output .reflist-lower-alpha{list-style-type:lower-alpha}.mw-parser-output .reflist-lower-greek{list-style-type:lower-greek}.mw-parser-output .reflist-lower-roman{list-style-type:lower-roman}

/* end https://en.wikipedia.org/ */

</style><div class="reflist">

/* start https://en.wikipedia.org/ */

.mw-parser-output cite.citation{font-style:inherit;word-wrap:break-word}.mw-parser-output .citation q{quotes:"\"""\"""'""'"}.mw-parser-output .citation:target{background-color:rgba(0,127,255,0.133)}.mw-parser-output .id-lock-free.id-lock-free a{background:url("./mw/Lock-green.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-limited.id-lock-limited a,.mw-parser-output .id-lock-registration.id-lock-registration a{background:url("./mw/Lock-gray-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-subscription.id-lock-subscription a{background:url("./mw/Lock-red-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .cs1-ws-icon a{background:url("./mw/Wikisource-logo.svg")right 0.1em center/12px no-repeat}body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-free a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-limited a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-registration a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-subscription a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .cs1-ws-icon a{background-size:contain;padding:0 1em 0 0}.mw-parser-output .cs1-code{color:inherit;background:inherit;border:none;padding:inherit}.mw-parser-output .cs1-hidden-error{display:none;color:var(--color-error,#d33)}.mw-parser-output .cs1-visible-error{color:var(--color-error,#d33)}.mw-parser-output .cs1-maint{display:none;color:#085;margin-left:0.3em}.mw-parser-output .cs1-kern-left{padding-left:0.2em}.mw-parser-output .cs1-kern-right{padding-right:0.2em}.mw-parser-output .citation .mw-selflink{font-weight:inherit}@media screen{.mw-parser-output .cs1-format{font-size:95%}html.skin-theme-clientpref-night .mw-parser-output .cs1-maint{color:#18911f}}@media screen and (prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .cs1-maint{color:#18911f}}

/* end https://en.wikipedia.org/ */

</style><cite id="CITEREFAndrew_J._Miller" class="citation web cs1">Andrew J. Miller. <a rel="nofollow" class="external text" href="http://www.esm.psu.edu/~ajm138/fortranexamples.html#ex1">"Fortran Examples"</a>. Retrieved 2013-09-14.</cite>

</li>

<li id="cite_note-2"><a href="#cite_ref-2">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20110516153643/http://www.newty.de/fpt/intro.html#what">"The Function Pointer Tutorials"</a>. logo. Archived from <a rel="nofollow" class="external text" href="http://www.newty.de/fpt/intro.html#what">the original</a> on 2011-05-16. Retrieved 2011-04-13. <q>Function Pointers are pointers, i.e. variables, which point to the address of a function</q></cite>

</li>

<li id="cite_note-3"><a href="#cite_ref-3">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20110516153643/http://www.newty.de/fpt/intro.html#top">"The Function Pointer Tutorials"</a>. logo. Archived from <a rel="nofollow" class="external text" href="http://www.newty.de/fpt/intro.html#top">the original</a> on 2011-05-16. Retrieved 2011-04-13. <q>Important note: A function pointer always points to a function with a specific signature! Thus all functions, you want to use with the same function pointer, must have the same parameters and return-type!</q></cite>

</li>

<li id="cite_note-4"><a href="#cite_ref-4">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="http://www.devx.com/tips/Tip/27126">"Expertise: Intermediate Language: C++: Use Functor for Callbacks in C++"</a>. DevX.com. 2005-01-31. Retrieved 2011-04-13. <q>If you want to use a member function as a callback function, then the member function needs to be associated with an object of the class before it can be called. In this case, you can use functor [with an example on this page].</q></cite>

</li>

<li id="cite_note-5"><a href="#cite_ref-5">^</a> <cite id="CITEREFAbrahams1978" class="citation book cs1">Abrahams, Paul (March 1978). <a rel="nofollow" class="external text" href="http://www.iron-spring.com/abrahams.pdf">The PL/I Programming Language</a> (PDF). Courant Mathematics and Computing Laboratory, New York University. pp. 22–24. Retrieved April 4, 2025.</cite>

</li>

</ol></div></div>

<div class="mw-heading mw-heading2"><h2 id="External_links">External links</h2></div>

<ul><li><a rel="nofollow" class="external text" href="https://web.archive.org/web/20041013202445/http://www.parashift.com/c++-faq-lite/pointers-to-members.html#faq-33.12">FAQ on Function Pointers</a>, things to avoid with function pointers, some information on using <a href="Function_object" title="Function object">function objects</a></li>

<li><a rel="nofollow" class="external text" href="http://www.newty.de/fpt/">Function Pointer Tutorials</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20180630152057/http://www.newty.de/fpt/">Archived</a> 2018-06-30 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, a guide to C/C++ function pointers, <a href="Callback_(computer_programming)" title="Callback (computer programming)">callbacks</a>, and <a href="Function_object" title="Function object">function objects</a> (functors)</li>

<li><a rel="nofollow" class="external text" href="http://www.codeproject.com/KB/cpp/FastDelegate.aspx">Member Function Pointers and the Fastest Possible C++ Delegates</a>, CodeProject article by Don Clugston</li>

<li><a rel="nofollow" class="external text" href="http://www.cplusplus.com/doc/tutorial/pointers.html">Pointer Tutorials</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20090405234937/http://www.cplusplus.com/doc/tutorial/pointers.html">Archived</a> 2009-04-05 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>, C++ documentation and tutorials</li>

<li><a rel="nofollow" class="external text" href="http://www.onlinecomputerteacher.net/pointers-in-c.html">C pointers explained</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20190609120644/http://www.onlinecomputerteacher.net/pointers-in-c.html">Archived</a> 2019-06-09 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a> a visual guide of pointers in C</li>

<li><a rel="nofollow" class="external text" href="http://www.codeproject.com/KB/security/Securefunctionpointer.aspx">Secure Function Pointer and Callbacks in Windows Programming</a>, CodeProject article by R. Selvam</li>

<li><a rel="nofollow" class="external text" href="http://publications.gbdirect.co.uk/c_book/chapter5/function_pointers.html">The C Book</a>, Function Pointers in C by "The C Book"</li>

<li><a rel="nofollow" class="external text" href="http://www.dbase.com/help/2_80/Language_Definition/IDH_LDEF_FUNCPOINTERS.htm">Function Pointers in dBASE dBL</a>, Function Pointer in dBASE dBL</li></ul></div><div><div class="zim-footer">

This article is issued from <a class="external text" title="Last edited on 2025-08-03" href="https://en.wikipedia.org/wiki/?title=Function_pointer&oldid=1304011439">Wikipedia</a>. The text is available under <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.en">Creative Commons Attribution-Share Alike 4.0</a> unless otherwise noted. Additional terms may apply for the media files.

</div>

</div></div>

</div>

</main>

</div>

</body></html>